#ifndef EPOLL_SERVER_H
#define EPOLL_SERVER_H

#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <string>
#include <functional>
#include <map>
#include <memory>
#include <vector>
#include <thread>
#include <mutex>
#include <atomic>

namespace network {

// 前向声明
class Connection;

// 连接事件回调函数类型
using ConnectionCallback = std::function<void(std::shared_ptr<Connection>)>;
// 消息回调函数类型
using MessageCallback = std::function<void(std::shared_ptr<Connection>, const std::string&)>;
// 关闭连接回调函数类型
using CloseCallback = std::function<void(std::shared_ptr<Connection>)>;

// 连接类，表示一个客户端连接
class Connection : public std::enable_shared_from_this<Connection> {
public:
    Connection(int sockfd, const struct sockaddr_in& addr);
    ~Connection();

    // 获取连接的socket文件描述符
    int getFd() const { return sockfd_; }
    
    // 获取客户端地址信息
    std::string getIp() const;
    int getPort() const;
    
    // 发送数据
    void send(const std::string& message);
    
    // 处理读事件
    void handleRead();
    
    // 处理写事件
    void handleWrite();
    
    // 处理连接关闭
    void handleClose();
    
    // 设置回调函数
    void setMessageCallback(const MessageCallback& cb) { messageCallback_ = cb; }
    void setCloseCallback(const CloseCallback& cb) { closeCallback_ = cb; }
    
    // 获取连接ID
    uint64_t getId() const { return id_; }

private:
    int sockfd_;                     // socket文件描述符
    struct sockaddr_in addr_;        // 客户端地址
    std::string inputBuffer_;        // 输入缓冲区
    std::string outputBuffer_;       // 输出缓冲区
    static std::atomic<uint64_t> nextId_; // 下一个连接ID
    uint64_t id_;                   // 连接ID
    std::mutex mutex_;              // 互斥锁，保护缓冲区的并发访问
    
    MessageCallback messageCallback_; // 消息回调函数
    CloseCallback closeCallback_;     // 关闭连接回调函数
};

// Epoll服务器类
class EpollServer {
public:
    EpollServer(int port, int threadNum = 4);
    ~EpollServer();
    
    // 启动服务器
    void start();
    
    // 停止服务器
    void stop();
    
    // 设置回调函数
    void setConnectionCallback(const ConnectionCallback& cb) { connectionCallback_ = cb; }
    void setMessageCallback(const MessageCallback& cb) { messageCallback_ = cb; }
    void setCloseCallback(const CloseCallback& cb) { closeCallback_ = cb; }

private:
    // 初始化socket
    bool initSocket();
    
    // 设置非阻塞模式
    void setNonBlocking(int sockfd);
    
    // 工作线程函数
    void workerThread();
    
    // 处理新的连接
    void handleNewConnection();
    
    // 处理事件
    void handleEvent(struct epoll_event& event);

private:
    int port_;                       // 监听端口
    int listenFd_;                   // 监听套接字
    int epollFd_;                    // epoll文件描述符
    bool running_;                   // 服务器运行状态
    int threadNum_;                  // 工作线程数
    std::vector<std::thread> threads_; // 工作线程池
    
    // 连接表，管理所有客户端连接
    std::map<int, std::shared_ptr<Connection>> connections_;
    std::mutex connectionsMutex_;    // 保护连接表的互斥锁
    
    // 回调函数
    ConnectionCallback connectionCallback_; // 新连接回调
    MessageCallback messageCallback_;       // 消息回调
    CloseCallback closeCallback_;           // 连接关闭回调
    
    static const int MAX_EVENTS = 1024;     // 单次处理的最大事件数
    static const int BUFFER_SIZE = 4096;    // 缓冲区大小
};

} // namespace network

#endif // EPOLL_SERVER_H 